home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 34 / Amiga Format CD34 (1998-11-20)(Future Publishing)(GB)[!][Christmas issue].iso / -seriously_amiga- / programming / c / mesa-2.6 / src / api1.c next >
C/C++ Source or Header  |  1998-10-01  |  53KB  |  2,018 lines
  1. /* $Id: api1.c,v 1.3 1997/11/05 03:25:52 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.5
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * api1.c
  26.  *
  27.  * Version 1.0  27 Jun 1998
  28.  * by Jarno van der Linden
  29.  * jarno@kcbbs.gen.nz
  30.  *
  31.  * File created from api1.c ver 1.3 and gl.h ver 1.26 using GenProtos
  32.  *
  33.  */
  34.  
  35.  
  36. #ifdef PC_HEADER
  37. #include "all.h"
  38. #else
  39. #include <stdio.h>
  40. #include <stdlib.h>
  41. #include "api.h"
  42. #include "bitmap.h"
  43. #include "context.h"
  44.  
  45. #include "drawpix.h"
  46.  
  47. #include "eval.h"
  48. #include "image.h"
  49. #include "macros.h"
  50. #include "matrix.h"
  51. #include "teximage.h"
  52. #include "types.h"
  53. #include "vb.h"
  54. #endif
  55.  
  56.  
  57.  
  58.  
  59. __asm __saveds void APIENTRY glAccum( register __d0 GLenum op, register __fp0 GLfloat value )
  60. {
  61.    GET_CONTEXT;
  62.    CHECK_CONTEXT;
  63.    (*CC->API.Accum)(CC, op, value);
  64. }
  65.  
  66.  
  67. __asm __saveds void APIENTRY glAlphaFunc( register __d0 GLenum func, register __fp0 GLclampf ref )
  68. {
  69.    GET_CONTEXT;
  70.    CHECK_CONTEXT;
  71.    (*CC->API.AlphaFunc)(CC, func, ref);
  72. }
  73.  
  74.  
  75. __asm __saveds GLboolean APIENTRY glAreTexturesResident( register __d0 GLsizei n, register __a0 const GLuint *textures,
  76.                                                          register __a1 GLboolean *residences )
  77. {
  78.    GET_CONTEXT;
  79.    CHECK_CONTEXT_RETURN(GL_FALSE);
  80.    return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
  81. }
  82.  
  83.  
  84. __asm __saveds void APIENTRY glArrayElement( register __d0 GLint i )
  85. {
  86.    GET_CONTEXT;
  87.    CHECK_CONTEXT;
  88.    (*CC->API.ArrayElement)(CC, i);
  89. }
  90.  
  91.  
  92. __asm __saveds void APIENTRY glBegin( register __d0 GLenum mode )
  93. {
  94.    GET_CONTEXT;
  95.    CHECK_CONTEXT;
  96.    (*CC->API.Begin)( CC, mode );
  97. }
  98.  
  99.  
  100. __asm __saveds void APIENTRY glBindTexture( register __d0 GLenum target, register __d1 GLuint texture )
  101. {
  102.    GET_CONTEXT;
  103.    CHECK_CONTEXT;
  104.    (*CC->API.BindTexture)(CC, target, texture);
  105. }
  106.  
  107.  
  108. __asm __saveds void APIENTRY glBitmapA(register __a0 void *vargs)
  109. {
  110.     struct glBitmapArgs {
  111.         GLsizei width;
  112.         GLsizei height;
  113.         GLfloat xorig;
  114.         GLfloat yorig;
  115.         GLfloat xmove;
  116.         GLfloat ymove;
  117.         GLubyte *bitmap;
  118.     } *args;
  119.  
  120.     args = (struct glBitmapArgs *)vargs;
  121.  
  122.     glBitmap(args->width, args->height, args->xorig, args->yorig, args->xmove, args->ymove, args->bitmap);
  123. }
  124.  
  125.  
  126. __asm __saveds void APIENTRY glBitmap( register __d0 GLsizei width, register __d1 GLsizei height,
  127.                                        register __fp0 GLfloat xorig, register __fp1 GLfloat yorig,
  128.                                        register __fp2 GLfloat xmove, register __fp3 GLfloat ymove,
  129.                                        register __a0 const GLubyte *bitmap )
  130. {
  131.    GET_CONTEXT;
  132.    CHECK_CONTEXT;
  133.    if (!CC->CompileFlag) {
  134.       /* execute only, try optimized case where no unpacking needed */
  135.       if (   CC->Unpack.LsbFirst==GL_FALSE
  136.           && CC->Unpack.Alignment==1
  137.           && CC->Unpack.RowLength==0
  138.           && CC->Unpack.SkipPixels==0
  139.           && CC->Unpack.SkipRows==0) {
  140.          /* Special case: no unpacking needed */
  141.          struct gl_image image;
  142.          image.Width = width;
  143.          image.Height = height;
  144.          image.Components = 0;
  145.          image.Type = GL_BITMAP;
  146.          image.Format = GL_COLOR_INDEX;
  147.          image.Data = (GLvoid *) bitmap;
  148.          (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  149.                              xmove, ymove, &image );
  150.       }
  151.       else {
  152.          struct gl_image *image;
  153.          image = gl_unpack_bitmap( CC, width, height, bitmap );
  154.          (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  155.                              xmove, ymove, image );
  156.          if (image) {
  157.             gl_free_image( image );
  158.          }
  159.       }
  160.    }
  161.    else {
  162.       /* compile and maybe execute */
  163.       struct gl_image *image;
  164.       image = gl_unpack_bitmap( CC, width, height, bitmap );
  165.       (*CC->API.Bitmap)(CC, width, height, xorig, yorig, xmove, ymove, image );
  166.    }
  167. }
  168.  
  169.  
  170. __asm __saveds void APIENTRY glBlendFunc( register __d0 GLenum sfactor, register __d1 GLenum dfactor )
  171. {
  172.    GET_CONTEXT;
  173.    CHECK_CONTEXT;
  174.    (*CC->API.BlendFunc)(CC, sfactor, dfactor);
  175. }
  176.  
  177.  
  178. __asm __saveds void APIENTRY glCallList( register __d0 GLuint list )
  179. {
  180.    GET_CONTEXT;
  181.    CHECK_CONTEXT;
  182.    (*CC->API.CallList)(CC, list);
  183. }
  184.  
  185.  
  186. __asm __saveds void APIENTRY glCallLists( register __d0 GLsizei n, register __d1 GLenum type, register __a0 const GLvoid *lists )
  187. {
  188.    GET_CONTEXT;
  189.    CHECK_CONTEXT;
  190.    (*CC->API.CallLists)(CC, n, type, lists);
  191. }
  192.  
  193.  
  194. __asm __saveds void APIENTRY glClear( register __d0 GLbitfield mask )
  195. {
  196.    GET_CONTEXT;
  197.    CHECK_CONTEXT;
  198.    (*CC->API.Clear)(CC, mask);
  199. }
  200.  
  201.  
  202. __asm __saveds void APIENTRY glClearAccum( register __fp0 GLfloat red, register __fp1 GLfloat green,
  203.                                            register __fp2 GLfloat blue, register __fp3 GLfloat alpha )
  204. {
  205.    GET_CONTEXT;
  206.    CHECK_CONTEXT;
  207.    (*CC->API.ClearAccum)(CC, red, green, blue, alpha);
  208. }
  209.  
  210.  
  211.  
  212. __asm __saveds void APIENTRY glClearIndex( register __fp0 GLfloat c )
  213. {
  214.    GET_CONTEXT;
  215.    CHECK_CONTEXT;
  216.    (*CC->API.ClearIndex)(CC, c);
  217. }
  218.  
  219.  
  220. __asm __saveds void APIENTRY glClearColor( register __fp0 GLclampf red,
  221.                                            register __fp1 GLclampf green,
  222.                                            register __fp2 GLclampf blue,
  223.                                            register __fp3 GLclampf alpha )
  224. {
  225.    GET_CONTEXT;
  226.    CHECK_CONTEXT;
  227.    (*CC->API.ClearColor)(CC, red, green, blue, alpha);
  228. }
  229.  
  230.  
  231. __asm __saveds void APIENTRY glClearDepth( register __fp0 GLclampd depth )
  232. {
  233.    GET_CONTEXT;
  234.    CHECK_CONTEXT;
  235.    (*CC->API.ClearDepth)( CC, depth );
  236. }
  237.  
  238.  
  239. __asm __saveds void APIENTRY glClearStencil( register __d0 GLint s )
  240. {
  241.    GET_CONTEXT;
  242.    CHECK_CONTEXT;
  243.    (*CC->API.ClearStencil)(CC, s);
  244. }
  245.  
  246.  
  247. __asm __saveds void APIENTRY glClipPlane( register __d0 GLenum plane, register __a0 const GLdouble *equation )
  248. {
  249.    GLfloat eq[4];
  250.    GET_CONTEXT;
  251.    CHECK_CONTEXT;
  252.    eq[0] = (GLfloat) equation[0];
  253.    eq[1] = (GLfloat) equation[1];
  254.    eq[2] = (GLfloat) equation[2];
  255.    eq[3] = (GLfloat) equation[3];
  256.    (*CC->API.ClipPlane)(CC, plane, eq );
  257. }
  258.  
  259.  
  260. __asm __saveds void APIENTRY glColor3b( register __d0 GLbyte red, register __d1 GLbyte green, register __d2 GLbyte blue )
  261. {
  262.    GET_CONTEXT;
  263.    (*CC->API.Color3f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  264.                        BYTE_TO_FLOAT(blue) );
  265. }
  266.  
  267.  
  268. __asm __saveds void APIENTRY glColor3d( register __fp0 GLdouble red, register __fp1 GLdouble green, register __fp2 GLdouble blue )
  269. {
  270.    GET_CONTEXT;
  271.    (*CC->API.Color3f)( CC, (GLfloat) red, (GLfloat) green, (GLfloat) blue );
  272. }
  273.  
  274.  
  275. __asm __saveds void APIENTRY glColor3f( register __fp0 GLfloat red, register __fp1 GLfloat green, register __fp2 GLfloat blue )
  276. {
  277.    GET_CONTEXT;
  278.    (*CC->API.Color3f)( CC, red, green, blue );
  279. }
  280.  
  281.  
  282. __asm __saveds void APIENTRY glColor3i( register __d0 GLint red, register __d1 GLint green, register __d2 GLint blue )
  283. {
  284.    GET_CONTEXT;
  285.    (*CC->API.Color3f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  286.                        INT_TO_FLOAT(blue) );
  287. }
  288.  
  289.  
  290. __asm __saveds void APIENTRY glColor3s( register __d0 GLshort red, register __d1 GLshort green, register __d2 GLshort blue )
  291. {
  292.    GET_CONTEXT;
  293.    (*CC->API.Color3f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  294.                        SHORT_TO_FLOAT(blue) );
  295. }
  296.  
  297.  
  298. __asm __saveds void APIENTRY glColor3ub( register __d0 GLubyte red, register __d1 GLubyte green, register __d2 GLubyte blue )
  299. {
  300.    GET_CONTEXT;
  301.    (*CC->API.Color4ub)( CC, red, green, blue, 255 );
  302. }
  303.  
  304.  
  305. __asm __saveds void APIENTRY glColor3ui( register __d0 GLuint red, register __d1 G